home *** CD-ROM | disk | FTP | other *** search
/ Libris Britannia 4 / science library(b).zip / science library(b) / CUGUK / APPLICAT / C034.ZIP / DBQ.C < prev    next >
Text File  |  2010-11-01  |  9KB  |  507 lines
  1. /*    SDB    Main routine    */
  2.  
  3. #include "bdscio.h"
  4. #include "dbqdefs.h"
  5.  
  6. main()
  7. {
  8.     pbuf = gbuf;
  9.     printf("DBQ - version 1.3\n");
  10.     db_sinit();
  11.     db_ifile("dbqinit.cmd");
  12.     while (TRUE) {
  13.         db_prompt("DBQ> ","\t> ");
  14.         if (!db_parse(NULL)) {
  15.             printf("### Error: %s ###\007\n",db_ertxt(dbv_errcode));
  16.         }
  17.     }
  18. }
  19.  
  20. int db_parse(fmt,a1,a2,a3,a4,a5,a6,a7,a8,a9)
  21.     char *fmt;
  22.  
  23. {
  24.     int sts;
  25. #ifdef DBPI
  26.     if (fmt)
  27.         db_scan(fmt,a1,a2,a3,a4,a5,a6,a7,a8,a9);
  28. #endif
  29.     switch (db_ntoken()) {
  30.  
  31.     case ';':    sts = TRUE;
  32.             break;
  33.  
  34. /* comment - # to end of line */
  35.  
  36.     case COMMENT:    db_flush(1);
  37.             sts = TRUE;
  38.             break;
  39.     case EXXIT:        /* close log if open */
  40.             if (dbv_lfp != NULL) {
  41.                 putc(CPMEOF,dbv_lfp);
  42.                 fclose(dbv_lfp);
  43.                 printf("DBQ.LOG closed\n");
  44.             }
  45.             exit();
  46.             break;
  47.  
  48.     case DELETE:
  49.             sts = delete();
  50.             break;
  51.     case INSERT:
  52.             sts = insert();
  53.             break;
  54.     case PRINT:
  55.             sts = print();
  56.             break;
  57.     case SELECT:
  58.             sts = select();
  59.             break;
  60.     case SORT:
  61.             sts = db_sort(NULL);
  62.             break;
  63.     case UPDATE:
  64.             sts = update();
  65.             break;
  66.     case HELP:
  67.             sts = db_help();
  68.             break;
  69.     case DEFYNE:
  70.             sts = mc_define(0);
  71.             break;
  72.     case PROMPT:
  73.             sts = mc_define(1);
  74.             break;
  75.     case SHOW:
  76.             sts = mc_show();
  77.             break;
  78.     case SET:
  79.             sts = db_set();
  80.             break;
  81. /* from DBA */
  82.     case COMPRESS:
  83.             sts = db_squeeze(NULL);
  84.             break;
  85.     case CREATE:
  86.             sts = create();
  87.             break;
  88.     case ERASE:
  89.             sts = db_erase();
  90.             break;
  91.     case RENAME:
  92.             sts = db_rename();
  93.             break;
  94.     case EXPORT:
  95.             sts = db_export(NULL);
  96.             break;
  97.     case EXTRACT:
  98.             sts = db_extract(NULL);
  99.             break;
  100.     case IMPORT:
  101.             sts = db_import(NULL);
  102.             break;
  103.     default:
  104.             RETERR(SYNTAX)
  105.     }
  106.  
  107.     return (sts);
  108. }
  109.  
  110. int db_set()
  111. {
  112.     int setval;
  113.  
  114.     while (db_token() == ID) {
  115.  
  116.         db_ntoken();
  117.  
  118.         if (db_scmp(dbv_tstring,"no") == 0) {
  119.             setval = FALSE;
  120.             if (db_token() != ID)
  121.                 { RETERR(BADSET) }
  122.             db_ntoken();
  123.         }
  124.         else
  125.             setval = TRUE;
  126.  
  127.         if (db_scmp(dbv_tstring,"fold") == 0)
  128.             dbv_fold = setval;
  129.         else if (db_scmp(dbv_tstring,"verify") == 0)
  130.             dbv_verify = setval;
  131.         else if (db_scmp(dbv_tstring,"log") == 0) {
  132.             dbv_logging = setval;
  133.             if ((setval) && (dbv_lfp == NULL)) {
  134.                 if ((dbv_lfp = CALLOC(BUFSIZ)) == NULL) {
  135.                     RETERR(INSMEM) }
  136.                 if (fcreat("DBQ.LOG",dbv_lfp) == ERROR) {
  137.                     CFREE(dbv_lfp);
  138.                     dbv_lfp = NULL;
  139.                     dbv_logging = NULL;
  140.                     RETERR(OUTCRE)
  141.                     }
  142.                 }
  143.             }
  144.         else if (db_scmp(dbv_tstring,"page") == 0) {
  145.             if (setval)
  146.             if (db_token() == NUMBER) {
  147.                 db_ntoken();
  148.                 dbv_pgln = dbv_tvalue;
  149.                 }
  150.             else
  151.                 dbv_pgln = 60;
  152.             else
  153.             dbv_pgln = 32000;
  154.             }
  155.     }
  156.     printf("Fold = %d, verify = %d, log = %d, page = %d\n",
  157.             dbv_fold,dbv_verify,dbv_logging,dbv_pgln);
  158.  
  159.     return (TRUE);
  160. }
  161.  
  162. int db_help()
  163. {
  164.     FILE *fp;
  165.     int ch,kbrep,curhelp,helping;
  166.  
  167.         /*    Borrow the output buffer    */
  168.  
  169.     fp = &obuf;
  170.     helping = TRUE;
  171.  
  172.     if ((fopen("DBQ.HLP",&obuf)) == ERROR) {
  173.         printf("Sorry - help file not available\n");
  174.         }
  175.     else {
  176.         while ((ch = getc(fp)) != CPMEOF)
  177.             if (ch == '?') {
  178.                 if ((curhelp = getc(fp)) == CPMEOF) break;
  179.                 if (helping) {
  180.                     printf("Press ENTER to continue, ^Z to quit, x for help on x...\n");
  181.                     kbrep = getchar();
  182.                     if (kbrep == -1) break;
  183.                     if (kbrep != '\n')
  184.                         helping = FALSE;
  185.                     }
  186.                 if (curhelp == kbrep)
  187.                     helping = TRUE;
  188.                 }
  189.             else
  190.                 if (helping) putchar(ch);
  191.         fclose(fp);
  192.     }
  193.  
  194.     return (TRUE);
  195. }
  196.  
  197. int create()
  198. {
  199.     struct relation *rptr;
  200.     char aname[STRINGMAX+1];
  201.     int atype,asize,ascale;
  202.  
  203.     if (db_ntoken() != ID)
  204.         { RETERR(SYNTAX) }
  205.  
  206.     if (!(rptr = db_rcreate(dbv_tstring)))
  207.         return (FALSE);
  208. /*
  209.     if (db_ntoken() != '(') {
  210.         free(rptr);
  211.         RETERR(SYNTAX)
  212.     }
  213. */
  214.     while (TRUE) {
  215.  
  216.         if (db_ntoken() != ID) {
  217.             free(rptr);
  218.             RETERR(SYNTAX)
  219.         }
  220.         strcpy(aname,dbv_tstring);
  221.  
  222.         db_ntoken();
  223.         if (dbv_token == CHARR)
  224.             atype = TCHAR;
  225.         else if (dbv_token == NUM)
  226.             atype = TNUM;
  227.         else {
  228.             free(rptr);
  229.             RETERR(SYNTAX)
  230.         }
  231.  
  232.         if (db_ntoken() != NUMBER) {
  233.             free(rptr);
  234.             RETERR(SYNTAX)
  235.         }
  236. /*
  237.         if ((atype == TCHAR) && (dbv_tvalue > STRINGMAX)) {
  238.             printf("Max CHAR=%d\n",STRINGMAX);
  239.             free(rptr);
  240.             RETERR(SYNTAX)
  241.         }
  242.  
  243.         if ((atype == TNUM) && (dbv_tvalue > NUMBERMAX)) {
  244.             printf("Max NUM=%d\n",NUMBERMAX);
  245.             free(rptr);
  246.             RETERR(SYNTAX)
  247.         }
  248. */
  249.         asize = dbv_tvalue;
  250.         ascale = 0;
  251.  
  252.         if (db_token() == NUMBER) {
  253.             db_ntoken();
  254.             ascale = dbv_tvalue;
  255.         }
  256.  
  257.         if (!db_rcattr(rptr,aname,atype,asize,ascale)) {
  258.             free(rptr);
  259.             return (FALSE);
  260.         }
  261.  
  262.         if (db_token() != ID)
  263.             break;
  264.     }
  265. /*
  266.     if (db_ntoken() != ')') {
  267.         free(rptr);
  268.         RETERR(SYNTAX)
  269.     }
  270.  
  271.     
  272.     if (db_ntoken() != NUMBER) {
  273.         free(rptr);
  274.         RETERR(SYNTAX)
  275.     }
  276. replace this with just 10 for starters */
  277.     dbv_tvalue = 10;
  278.     if (!db_rcheader(rptr))
  279.         return (FALSE);
  280.     if (!db_rctuples(rptr,dbv_tvalue))
  281.         return (FALSE);
  282.     if (!db_rcdone(rptr))
  283.         return (FALSE);
  284.  
  285.     return (TRUE);
  286. }
  287.  
  288. int db_erase()
  289. {
  290.     char filename[RNSIZE+13];
  291.     if (db_ntoken() != ID)
  292.         { RETERR(SYNTAX) }
  293.  
  294.     sprintf(filename,"%s.dbq",dbv_tstring);
  295.     unlink(&filename);
  296.  
  297.     return(TRUE);
  298. }
  299.  
  300. int db_rename()
  301. {
  302.     char renfrom[RNSIZE+13], rento[RNSIZE+13];
  303.  
  304.     if (db_ntoken() != ID)
  305.         { RETERR(SYNTAX) }
  306.  
  307.     sprintf(renfrom,"%s.dbq",dbv_tstring);
  308.  
  309.     if (db_ntoken() != ID)
  310.         { RETERR(SYNTAX) }
  311.  
  312.     sprintf(rento,"%s.dbq",dbv_tstring);
  313.  
  314.     if (rename(renfrom,rento) == -1)
  315.         { RETERR(RELFNF) }
  316.  
  317.     return (TRUE);
  318. }
  319.  
  320.  
  321. int mc_define(fromcon)
  322. int fromcon;
  323. {
  324.     struct macro *mptr,*mlast;
  325.     struct mtext *tptr,*tlast;
  326.     char textline[LINEMAX+1];
  327.  
  328.     if ((db_xntoken() != ID) && (dbv_token != STRING))
  329.         { RETERR(SYNTAX) };
  330.  
  331.     if (!fromcon)
  332.        if (!db_flush(0))
  333.         return (FALSE);
  334.  
  335.     for (mptr = dbv_macros, mlast = NULL; mptr != NULL; mlast =mptr,
  336.         mptr = mptr->mc_next)
  337.         if (db_scmp(mptr->mc_name,dbv_tstring) == 0) {
  338.             if (mlast == NULL)
  339.                 dbv_macros = mptr->mc_next;
  340.             else
  341.                 mlast->mc_next = mptr->mc_next;
  342.             mc_free(mptr);
  343.         }
  344.  
  345.     if ((mptr = CALLOC(MACSIZE)) == NULL)
  346.         { RETERR(INSMEM) };
  347.     if ((mptr->mc_name = CALLOC(strlen(dbv_tstring)+1)) == NULL) {
  348.         CFREE(mptr);
  349.         RETERR(INSMEM)
  350.     }
  351.  
  352.     strcpy(mptr->mc_name,dbv_tstring);
  353.     mptr->mc_mtext = NULL;
  354.  
  355.     db_prompt(NULL,"DEFINE> ");
  356.  
  357.     for (tlast = NULL; ; tlast = tptr) {
  358.  
  359.         if (fromcon) {
  360.             printf("Enter %s ",dbv_tstring);
  361.             linein(textline);
  362.         }
  363.         else
  364.             db_gline(textline);
  365.  
  366.         if (textline[0] == EOS || textline[0] == '\n')
  367.             if (fromcon) {
  368.                 textline[0] = '#';
  369.                 textline[1] = EOS;
  370.             } else
  371.                 break;
  372.  
  373.         if ((tptr = CALLOC(MTSIZE)) == NULL) {
  374.             mc_free(mptr);
  375.             RETERR(INSMEM)
  376.         }
  377.  
  378.     /*    Add an inter word space        */
  379.  
  380.         if (!fromcon) strcat(textline," ");
  381.         if ((tptr->mt_text = CALLOC(strlen(textline)+1)) == NULL) {
  382.             mc_free(mptr);
  383.             RETERR(INSMEM)
  384.         }
  385.         if (dbv_token == STRING) {
  386.             strcpy(tptr->mt_text,"\"");
  387.             strcat(tptr->mt_text,textline);
  388.                 /* replace linefeed with dblquote */
  389.             tptr->mt_text[strlen(tptr->mt_text)-1] = 34;
  390.             }
  391.         else
  392.             strcpy(tptr->mt_text,textline);
  393.         tptr->mt_next = NULL;
  394.  
  395.         if (tlast == NULL)
  396.             mptr->mc_mtext = tptr;
  397.         else
  398.             tlast->mt_next = tptr;
  399.  
  400.         if (fromcon) {
  401.             tlast = tptr;
  402.             break;
  403.         }
  404.     }
  405.  
  406.     if (tlast == NULL)
  407.         mc_free(mptr);
  408.     else {
  409.         mptr->mc_next = dbv_macros;
  410.         dbv_macros = mptr;
  411.     }
  412.  
  413.     return (TRUE);
  414. }
  415.  
  416. int mc_show()
  417. {
  418.     struct macro *mptr;
  419.     struct mtext *tptr;
  420.  
  421. /*    just show ; will list macros    */
  422.  
  423.     if (db_xntoken() != ID) {
  424.         for (mptr = dbv_macros; mptr != NULL; mptr = mptr->mc_next)
  425.             printf("\t%s\n",mptr->mc_name);
  426.         return(TRUE);
  427.         }
  428.  
  429.     for (mptr = dbv_macros; mptr != NULL; mptr = mptr->mc_next)
  430.         if (db_scmp(mptr->mc_name,dbv_tstring) == 0) {
  431.             for (tptr = mptr->mc_mtext; tptr != NULL; tptr = tptr->mt_next)
  432.                 printf("\t%s\n",tptr->mt_text);
  433.             break;
  434.         }
  435.  
  436.     if (mptr == NULL)
  437.         printf("### Procedure <%s> not found ###\007\n",dbv_tstring);
  438.  
  439.     return(TRUE);
  440. }
  441.  
  442. int mc_free(mptr)
  443.     struct macro *mptr;
  444. {
  445.     struct mtext *tptr;
  446.  
  447.     while ((tptr = mptr->mc_mtext) != NULL) {
  448.         mptr->mc_mtext = tptr->mt_next;
  449.         CFREE(tptr->mt_text);
  450.         CFREE(tptr);
  451.     }
  452.     CFREE(mptr->mc_name);
  453.     CFREE(mptr);
  454. }
  455.  
  456. /*    Debug routines for memory allocation - remove comments if reqd.    */
  457. /*
  458. char *malloc(syze)
  459.     int syze;
  460. {
  461.     char *mptr;
  462.  
  463.     mptr = alloc(syze);
  464.     printf("malloc: allocated %d at %u\n",syze,mptr);
  465.  
  466.     return (mptr);
  467. }
  468.  
  469. mfree(mptr)
  470.     char *mptr;
  471. {
  472.     printf("mfree: freed at %u\n",mptr);
  473.     hfree(mptr);
  474. }
  475. */
  476.  
  477. hfree(block)
  478.   char *block;
  479. {
  480.   struct _header *p, *q;
  481.  
  482.   if (block != NULL) {
  483.   p = block - 4;
  484.   for (q = _allocp; !(p > q  &&  p < q->_ptr); q = q->_ptr)
  485.     if (q >= q->_ptr  &&  (p > q  ||  p < q->_ptr))  break;
  486.  
  487.   if (p + p->_size  ==  q->_ptr) {
  488.       p->_size += q->_ptr->_size;
  489.       p->_ptr   = q->_ptr->_ptr;
  490.     }
  491.   else  p->_ptr = q->_ptr;
  492.  
  493.   if (q + q->_size  ==  p) {
  494.       q->_size += p->_size;
  495.       q->_ptr   = p->_ptr;
  496.     }
  497.   else  q->_ptr = p;
  498.  
  499.   _allocp = q;
  500.   }
  501. }
  502.  
  503. e  ==  p) {
  504.       q->_size += p->_size;
  505.       q->_ptr   = p->_ptr;
  506.     }
  507.